/*
 * Copyright (C), 2002-2016, 苏宁易购电子商务有限公司
 * FileName: ModelCommClusterServiceImpl.java
 * Author:   13075787
 * Date:     2016年7月4日 下午7:52:13
 * Description: //模块目的、功能描述      
 * History: //修改记录
 * <author>      <time>      <version>    <desc>
 * 修改人姓名             修改时间            版本号                  描述
 */
package com.suning.sawp.service.impl.model;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.suning.framework.dal.client.DalClient;
import com.suning.sawp.intf.model.ModelCommClusterVo;
import com.suning.sawp.intf.model.ModelCommodityBaseInfo;
import com.suning.sawp.intf.model.ModelZoneInfo;
import com.suning.sawp.intf.precharge.SequenceSerivce;
import com.suning.sawp.service.util.BeanUtil;

/**
 * 样机管理<br>
 * 样机商品簇信息相关
 *
 * @author 13075787
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@Service("modelCommClusterDaoService")
public class ModelCommClusterDaoServiceImpl {

    private static final int NUM_ZERO = 0;

    private static final int NUM_ONE = 1;

    private static final int NUM_TWO = 2;

    /**
     * sqlMap中属性值
     */
    private static final String SQL_COUNT_KEY = "NUM";

    /**
     * 自增序列key
     */
    private static final String SEQUENCE_CLUSTER_CODE_KEY = "MODE_SEQUENCE_CLUSTER_CODE";

    @Resource
    DalClient dalClient;

    @Autowired
    SequenceSerivce sequenceSerivce;

    /**
     * 功能描述: <br>
     * 查询某个商品的单条簇记录
     *
     * @param orgCode
     * @param commCode
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public String queryModelCommCluster(String orgCode, String commCode) {
        String result = null;
        // 判空
        if (StringUtils.isNotBlank(orgCode) && StringUtils.isNotBlank(commCode)) {
            String locCommCode = CmmdtyUtils.transform9PartNumber(commCode);
            Map<String, Object> paramMap = new HashMap<String, Object>();
            paramMap.put("orgCode", orgCode);
            paramMap.put("commCode", locCommCode);
            ModelCommClusterVo comm = dalClient.queryForObject("MODEL_COMMODITY_CLUSTER.SELECT_MODEL_COMM_CLUSTER",
                    paramMap, ModelCommClusterVo.class);
            if (null != comm) {
                result = comm.getClusterCode();
            }
        }
        return result;
    }

    /**
     * 功能描述: <br>
     * 根据某个商品编码，查询该商品编码所在簇的商品簇列表
     *
     * @param orgCode
     * @param commCode
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public List<ModelCommClusterVo> queryModelCommClusters(String orgCode, String commCode) {
        List<ModelCommClusterVo> result = null;
        // 判空
        if (StringUtils.isNotBlank(orgCode) && StringUtils.isNotBlank(commCode)) {
            String locCommCode = CmmdtyUtils.transform9PartNumber(commCode);
            Map<String, Object> paramMap = new HashMap<String, Object>();
            paramMap.put("orgCode", orgCode);
            paramMap.put("commCode", locCommCode);
            result = dalClient.queryForList("MODEL_COMMODITY_CLUSTER.SELECT_MODEL_COMM_CLUSTERS", paramMap,
                    ModelCommClusterVo.class);
        }
        return result;
    }

    /**
     * 功能描述: <br>
     * 查询某个商品所在簇的商品总个数(包括自己)
     *
     * @param orgCode
     * @param commCode
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public Integer[] queryModelCommClusterCount(String orgCode, List<String> commCodes) {
        Integer[] result = null;
        if (StringUtils.isNotBlank(orgCode) && CollectionUtils.isNotEmpty(commCodes)) {
            result = new Integer[commCodes.size()];
            Map<String, Object> paramMap = new HashMap<String, Object>();
            paramMap.put("orgCode", orgCode);
            for (int i = 0; i < commCodes.size(); i++) {
                // 首先默认塞入0值
                result[i] = NUM_ZERO;
                paramMap.put("commCode", CmmdtyUtils.transform9PartNumber(commCodes.get(i)));
                Map<String, Object> retMap = dalClient
                        .queryForMap("MODEL_COMMODITY_CLUSTER.SELECT_COUNT_MODEL_COMM_CLUSTERS", paramMap);
                // 结果判空
                if (null != retMap && null != retMap.get(SQL_COUNT_KEY)) {
                    result[i] = Integer.valueOf(String.valueOf((Long) retMap.get(SQL_COUNT_KEY)));
                }
            }
        }
        return result;
    }

    /**
     * 功能描述: <br>
     * 删除指定商品所在簇下的某个商品
     * 
     * @param commCode
     * @param delCommCode
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public boolean deleteClusterComm(String orgCode, String commCode, String delCommCode) {
        boolean result = false;
        if (StringUtils.isNotBlank(orgCode) && StringUtils.isNotBlank(commCode)
                && StringUtils.isNotBlank(delCommCode)) {
            String locCommCode = CmmdtyUtils.transform9PartNumber(commCode);
            String locDelCommCode = CmmdtyUtils.transform9PartNumber(delCommCode);
            // 首先查询下指定商品所在簇的簇商品列表
            List<ModelCommClusterVo> clusters = this.queryModelCommClusters(orgCode, locCommCode);
            if (CollectionUtils.isNotEmpty(clusters)) {
                String clusterId = null != clusters.get(NUM_ZERO) ? clusters.get(NUM_ZERO).getClusterCode() : null;
                Map<String, Object> paramMap = new HashMap<String, Object>();
                // 若返回的簇列表 小于等于2，则将两条数据(即整个簇)删除
                if (clusters.size() <= NUM_TWO) {
                    if (!this.checkExistCluster(clusters, locDelCommCode)) {
                        // 不存在说明已被删除,返回成功
                        result = true;
                    }
                } else {
                    // 将要删除的商品编码删除
                    paramMap.put("commCode", delCommCode);
                }
                // 执行删除操作 - 未删除且簇id存在
                if (StringUtils.isNotBlank(clusterId) && !result) {
                    paramMap.put("clusterCode", clusterId);
                    paramMap.put("orgCode", orgCode);
                    dalClient.execute("MODEL_COMMODITY_CLUSTER.DELETE_MODEL_COMM_CLUSTER", paramMap);
                    result = true;
                }
            } else {
                // 为空则说明，该商品没有簇关系，返回删除成功
                result = true;
            }
        }
        return result;
    }

    /**
     * 功能描述: <br>
     * 检查某个样机编码是否存在在这个簇列表中
     */
    private boolean checkExistCluster(List<ModelCommClusterVo> clusters, String checkCommCode) {
        boolean result = false;
        if (CollectionUtils.isNotEmpty(clusters)) {
            for (ModelCommClusterVo modelCommClusterVo : clusters) {
                if (null != modelCommClusterVo && StringUtils.isNotBlank(modelCommClusterVo.getCommCode())
                        && modelCommClusterVo.getCommCode().equals(checkCommCode)) {
                    result = true;
                    break;
                }
            }
        }
        return result;
    }

    /**
     * 功能描述: <br>
     *
     * @param orgCode
     * @param commCode
     * @param addCommCode
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    @SuppressWarnings("unchecked")
    public String addModelCommCluster(ModelZoneInfo modelZone, ModelCommodityBaseInfo comm,
            ModelCommodityBaseInfo addComm) {
        String result = null;
        if (null != comm && null != addComm && null != modelZone && StringUtils.isNotBlank(modelZone.getOrgCode())
                && StringUtils.isNotBlank(comm.getCommCode()) && StringUtils.isNotBlank(addComm.getCommCode())) {
            // 首先删除被添加的商品已经在其他簇中的记录
            this.deleteClusterComm(modelZone.getOrgCode(), addComm.getCommCode(), addComm.getCommCode());

            String clusterCode = this.queryModelCommCluster(modelZone.getOrgCode(), comm.getCommCode());
            if (StringUtils.isBlank(clusterCode)) {
                // 若簇id不存在，则生产一个簇id编码
                clusterCode = this.sequenceClusterCode();
            }
            // 更新插入数据
            Map<String, Object>[] batchValues = new HashMap[NUM_TWO];
            Map<String, Object> commonMap = BeanUtil.describe(modelZone);
            commonMap.put("clusterCode", clusterCode);
            Map<String, Object> commMap = BeanUtil.describe(comm);
            commMap.putAll(commonMap);
            Map<String, Object> addCommMap = BeanUtil.describe(addComm);
            // 加上大区与分公司信息
            addCommMap.putAll(commonMap);
            batchValues[NUM_ZERO] = commMap;
            batchValues[NUM_ONE] = addCommMap;
            dalClient.batchUpdate("MODEL_COMMODITY_CLUSTER.UPSERT_MODEL_COMM_CLUSTER", batchValues);
            result = clusterCode;
        }
        return result;
    }

    /**
     * 功能描述: <br>
     * 获取样机簇自增id唯一序列值
     *
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public String sequenceClusterCode() {
        return sequenceSerivce.incrSequenceNumber(SEQUENCE_CLUSTER_CODE_KEY);
    }

}
